/*!-----------------------------------------------------------------------------
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Version: 0.46.0(21007360cad28648bdf46282a2592cb47c3a7a6f)
 * Released under the MIT license
 * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
 *-----------------------------------------------------------------------------*/
define('vs/basic-languages/ruby/ruby', ['require', 'require'], require => {
  'use strict'
  var moduleExports = (() => {
    var o = Object.defineProperty
    var i = Object.getOwnPropertyDescriptor
    var c = Object.getOwnPropertyNames
    var d = Object.prototype.hasOwnProperty
    var p = (t, e) => {
        for (var r in e) o(t, r, { get: e[r], enumerable: !0 })
      },
      l = (t, e, r, s) => {
        if ((e && typeof e == 'object') || typeof e == 'function')
          for (let n of c(e))
            !d.call(t, n) && n !== r && o(t, n, { get: () => e[n], enumerable: !(s = i(e, n)) || s.enumerable })
        return t
      }
    var a = t => l(o({}, '__esModule', { value: !0 }), t)
    var m = {}
    p(m, { conf: () => g, language: () => x })
    var g = {
        comments: { lineComment: '#', blockComment: ['=begin', '=end'] },
        brackets: [
          ['(', ')'],
          ['{', '}'],
          ['[', ']'],
        ],
        autoClosingPairs: [
          { open: '{', close: '}' },
          { open: '[', close: ']' },
          { open: '(', close: ')' },
          { open: '"', close: '"' },
          { open: "'", close: "'" },
        ],
        surroundingPairs: [
          { open: '{', close: '}' },
          { open: '[', close: ']' },
          { open: '(', close: ')' },
          { open: '"', close: '"' },
          { open: "'", close: "'" },
        ],
        indentationRules: {
          increaseIndentPattern: new RegExp(
            `^\\s*((begin|class|(private|protected)\\s+def|def|else|elsif|ensure|for|if|module|rescue|unless|until|when|while|case)|([^#]*\\sdo\\b)|([^#]*=\\s*(case|if|unless)))\\b([^#\\{;]|("|'|/).*\\4)*(#.*)?$`,
          ),
          decreaseIndentPattern: new RegExp(
            '^\\s*([}\\]]([,)]?\\s*(#|$)|\\.[a-zA-Z_]\\w*\\b)|(end|rescue|ensure|else|elsif|when)\\b)',
          ),
        },
      },
      x = {
        tokenPostfix: '.ruby',
        keywords: [
          '__LINE__',
          '__ENCODING__',
          '__FILE__',
          'BEGIN',
          'END',
          'alias',
          'and',
          'begin',
          'break',
          'case',
          'class',
          'def',
          'defined?',
          'do',
          'else',
          'elsif',
          'end',
          'ensure',
          'for',
          'false',
          'if',
          'in',
          'module',
          'next',
          'nil',
          'not',
          'or',
          'redo',
          'rescue',
          'retry',
          'return',
          'self',
          'super',
          'then',
          'true',
          'undef',
          'unless',
          'until',
          'when',
          'while',
          'yield',
        ],
        keywordops: ['::', '..', '...', '?', ':', '=>'],
        builtins: [
          'require',
          'public',
          'private',
          'include',
          'extend',
          'attr_reader',
          'protected',
          'private_class_method',
          'protected_class_method',
          'new',
        ],
        declarations: ['module', 'class', 'def', 'case', 'do', 'begin', 'for', 'if', 'while', 'until', 'unless'],
        linedecls: ['def', 'case', 'do', 'begin', 'for', 'if', 'while', 'until', 'unless'],
        operators: [
          '^',
          '&',
          '|',
          '<=>',
          '==',
          '===',
          '!~',
          '=~',
          '>',
          '>=',
          '<',
          '<=',
          '<<',
          '>>',
          '+',
          '-',
          '*',
          '/',
          '%',
          '**',
          '~',
          '+@',
          '-@',
          '[]',
          '[]=',
          '`',
          '+=',
          '-=',
          '*=',
          '**=',
          '/=',
          '^=',
          '%=',
          '<<=',
          '>>=',
          '&=',
          '&&=',
          '||=',
          '|=',
        ],
        brackets: [
          { open: '(', close: ')', token: 'delimiter.parenthesis' },
          { open: '{', close: '}', token: 'delimiter.curly' },
          { open: '[', close: ']', token: 'delimiter.square' },
        ],
        symbols: /[=><!~?:&|+\-*\/\^%\.]+/,
        escape: /(?:[abefnrstv\\"'\n\r]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2}|u[0-9A-Fa-f]{4})/,
        escapes: /\\(?:C\-(@escape|.)|c(@escape|.)|@escape)/,
        decpart: /\d(_?\d)*/,
        decimal: /0|@decpart/,
        delim: /[^a-zA-Z0-9\s\n\r]/,
        heredelim: /(?:\w+|'[^']*'|"[^"]*"|`[^`]*`)/,
        regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
        regexpesc: /\\(?:[AzZbBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})?/,
        tokenizer: {
          root: [
            [
              /^(\s*)([a-z_]\w*[!?=]?)/,
              [
                'white',
                {
                  cases: {
                    'for|until|while': { token: 'keyword.$2', next: '@dodecl.$2' },
                    '@declarations': { token: 'keyword.$2', next: '@root.$2' },
                    end: { token: 'keyword.$S2', next: '@pop' },
                    '@keywords': 'keyword',
                    '@builtins': 'predefined',
                    '@default': 'identifier',
                  },
                },
              ],
            ],
            [
              /[a-z_]\w*[!?=]?/,
              {
                cases: {
                  'if|unless|while|until': { token: 'keyword.$0x', next: '@modifier.$0x' },
                  for: { token: 'keyword.$2', next: '@dodecl.$2' },
                  '@linedecls': { token: 'keyword.$0', next: '@root.$0' },
                  end: { token: 'keyword.$S2', next: '@pop' },
                  '@keywords': 'keyword',
                  '@builtins': 'predefined',
                  '@default': 'identifier',
                },
              },
            ],
            [/[A-Z][\w]*[!?=]?/, 'constructor.identifier'],
            [/\$[\w]*/, 'global.constant'],
            [/@[\w]*/, 'namespace.instance.identifier'],
            [/@@@[\w]*/, 'namespace.class.identifier'],
            [/<<[-~](@heredelim).*/, { token: 'string.heredoc.delimiter', next: '@heredoc.$1' }],
            [/[ \t\r\n]+<<(@heredelim).*/, { token: 'string.heredoc.delimiter', next: '@heredoc.$1' }],
            [/^<<(@heredelim).*/, { token: 'string.heredoc.delimiter', next: '@heredoc.$1' }],
            { include: '@whitespace' },
            [/"/, { token: 'string.d.delim', next: '@dstring.d."' }],
            [/'/, { token: 'string.sq.delim', next: '@sstring.sq' }],
            [/%([rsqxwW]|Q?)/, { token: '@rematch', next: 'pstring' }],
            [/`/, { token: 'string.x.delim', next: '@dstring.x.`' }],
            [/:(\w|[$@])\w*[!?=]?/, 'string.s'],
            [/:"/, { token: 'string.s.delim', next: '@dstring.s."' }],
            [/:'/, { token: 'string.s.delim', next: '@sstring.s' }],
            [/\/(?=(\\\/|[^\/\n])+\/)/, { token: 'regexp.delim', next: '@regexp' }],
            [/[{}()\[\]]/, '@brackets'],
            [/@symbols/, { cases: { '@keywordops': 'keyword', '@operators': 'operator', '@default': '' } }],
            [/[;,]/, 'delimiter'],
            [/0[xX][0-9a-fA-F](_?[0-9a-fA-F])*/, 'number.hex'],
            [/0[_oO][0-7](_?[0-7])*/, 'number.octal'],
            [/0[bB][01](_?[01])*/, 'number.binary'],
            [/0[dD]@decpart/, 'number'],
            [/@decimal((\.@decpart)?([eE][\-+]?@decpart)?)/, { cases: { $1: 'number.float', '@default': 'number' } }],
          ],
          dodecl: [
            [/^/, { token: '', switchTo: '@root.$S2' }],
            [
              /[a-z_]\w*[!?=]?/,
              {
                cases: {
                  end: { token: 'keyword.$S2', next: '@pop' },
                  do: { token: 'keyword', switchTo: '@root.$S2' },
                  '@linedecls': { token: '@rematch', switchTo: '@root.$S2' },
                  '@keywords': 'keyword',
                  '@builtins': 'predefined',
                  '@default': 'identifier',
                },
              },
            ],
            { include: '@root' },
          ],
          modifier: [
            [/^/, '', '@pop'],
            [
              /[a-z_]\w*[!?=]?/,
              {
                cases: {
                  end: { token: 'keyword.$S2', next: '@pop' },
                  'then|else|elsif|do': { token: 'keyword', switchTo: '@root.$S2' },
                  '@linedecls': { token: '@rematch', switchTo: '@root.$S2' },
                  '@keywords': 'keyword',
                  '@builtins': 'predefined',
                  '@default': 'identifier',
                },
              },
            ],
            { include: '@root' },
          ],
          sstring: [
            [/[^\\']+/, 'string.$S2'],
            [/\\\\|\\'|\\$/, 'string.$S2.escape'],
            [/\\./, 'string.$S2.invalid'],
            [/'/, { token: 'string.$S2.delim', next: '@pop' }],
          ],
          dstring: [
            [/[^\\`"#]+/, 'string.$S2'],
            [/#/, 'string.$S2.escape', '@interpolated'],
            [/\\$/, 'string.$S2.escape'],
            [/@escapes/, 'string.$S2.escape'],
            [/\\./, 'string.$S2.escape.invalid'],
            [/[`"]/, { cases: { '$#==$S3': { token: 'string.$S2.delim', next: '@pop' }, '@default': 'string.$S2' } }],
          ],
          heredoc: [
            [
              /^(\s*)(@heredelim)$/,
              {
                cases: {
                  '$2==$S2': ['string.heredoc', { token: 'string.heredoc.delimiter', next: '@pop' }],
                  '@default': ['string.heredoc', 'string.heredoc'],
                },
              },
            ],
            [/.*/, 'string.heredoc'],
          ],
          interpolated: [
            [/\$\w*/, 'global.constant', '@pop'],
            [/@\w*/, 'namespace.class.identifier', '@pop'],
            [/@@@\w*/, 'namespace.instance.identifier', '@pop'],
            [/[{]/, { token: 'string.escape.curly', switchTo: '@interpolated_compound' }],
            ['', '', '@pop'],
          ],
          interpolated_compound: [[/[}]/, { token: 'string.escape.curly', next: '@pop' }], { include: '@root' }],
          pregexp: [
            { include: '@whitespace' },
            [
              /[^\(\{\[\\]/,
              {
                cases: {
                  '$#==$S3': { token: 'regexp.delim', next: '@pop' },
                  '$#==$S2': { token: 'regexp.delim', next: '@push' },
                  '~[)}\\]]': '@brackets.regexp.escape.control',
                  '~@regexpctl': 'regexp.escape.control',
                  '@default': 'regexp',
                },
              },
            ],
            { include: '@regexcontrol' },
          ],
          regexp: [
            { include: '@regexcontrol' },
            [/[^\\\/]/, 'regexp'],
            ['/[ixmp]*', { token: 'regexp.delim' }, '@pop'],
          ],
          regexcontrol: [
            [
              /(\{)(\d+(?:,\d*)?)(\})/,
              ['@brackets.regexp.escape.control', 'regexp.escape.control', '@brackets.regexp.escape.control'],
            ],
            [/(\[)(\^?)/, ['@brackets.regexp.escape.control', { token: 'regexp.escape.control', next: '@regexrange' }]],
            [/(\()(\?[:=!])/, ['@brackets.regexp.escape.control', 'regexp.escape.control']],
            [/\(\?#/, { token: 'regexp.escape.control', next: '@regexpcomment' }],
            [/[()]/, '@brackets.regexp.escape.control'],
            [/@regexpctl/, 'regexp.escape.control'],
            [/\\$/, 'regexp.escape'],
            [/@regexpesc/, 'regexp.escape'],
            [/\\\./, 'regexp.invalid'],
            [/#/, 'regexp.escape', '@interpolated'],
          ],
          regexrange: [
            [/-/, 'regexp.escape.control'],
            [/\^/, 'regexp.invalid'],
            [/\\$/, 'regexp.escape'],
            [/@regexpesc/, 'regexp.escape'],
            [/[^\]]/, 'regexp'],
            [/\]/, '@brackets.regexp.escape.control', '@pop'],
          ],
          regexpcomment: [
            [/[^)]+/, 'comment'],
            [/\)/, { token: 'regexp.escape.control', next: '@pop' }],
          ],
          pstring: [
            [/%([qws])\(/, { token: 'string.$1.delim', switchTo: '@qstring.$1.(.)' }],
            [/%([qws])\[/, { token: 'string.$1.delim', switchTo: '@qstring.$1.[.]' }],
            [/%([qws])\{/, { token: 'string.$1.delim', switchTo: '@qstring.$1.{.}' }],
            [/%([qws])</, { token: 'string.$1.delim', switchTo: '@qstring.$1.<.>' }],
            [/%([qws])(@delim)/, { token: 'string.$1.delim', switchTo: '@qstring.$1.$2.$2' }],
            [/%r\(/, { token: 'regexp.delim', switchTo: '@pregexp.(.)' }],
            [/%r\[/, { token: 'regexp.delim', switchTo: '@pregexp.[.]' }],
            [/%r\{/, { token: 'regexp.delim', switchTo: '@pregexp.{.}' }],
            [/%r</, { token: 'regexp.delim', switchTo: '@pregexp.<.>' }],
            [/%r(@delim)/, { token: 'regexp.delim', switchTo: '@pregexp.$1.$1' }],
            [/%(x|W|Q?)\(/, { token: 'string.$1.delim', switchTo: '@qqstring.$1.(.)' }],
            [/%(x|W|Q?)\[/, { token: 'string.$1.delim', switchTo: '@qqstring.$1.[.]' }],
            [/%(x|W|Q?)\{/, { token: 'string.$1.delim', switchTo: '@qqstring.$1.{.}' }],
            [/%(x|W|Q?)</, { token: 'string.$1.delim', switchTo: '@qqstring.$1.<.>' }],
            [/%(x|W|Q?)(@delim)/, { token: 'string.$1.delim', switchTo: '@qqstring.$1.$2.$2' }],
            [/%([rqwsxW]|Q?)./, { token: 'invalid', next: '@pop' }],
            [/./, { token: 'invalid', next: '@pop' }],
          ],
          qstring: [
            [/\\$/, 'string.$S2.escape'],
            [/\\./, 'string.$S2.escape'],
            [
              /./,
              {
                cases: {
                  '$#==$S4': { token: 'string.$S2.delim', next: '@pop' },
                  '$#==$S3': { token: 'string.$S2.delim', next: '@push' },
                  '@default': 'string.$S2',
                },
              },
            ],
          ],
          qqstring: [[/#/, 'string.$S2.escape', '@interpolated'], { include: '@qstring' }],
          whitespace: [
            [/[ \t\r\n]+/, ''],
            [/^\s*=begin\b/, 'comment', '@comment'],
            [/#.*$/, 'comment'],
          ],
          comment: [
            [/[^=]+/, 'comment'],
            [/^\s*=begin\b/, 'comment.invalid'],
            [/^\s*=end\b.*/, 'comment', '@pop'],
            [/[=]/, 'comment'],
          ],
        },
      }
    return a(m)
  })()
  return moduleExports
})
